37 research outputs found
Positive Dependency Graphs Revisited
Theory of stable models is the mathematical basis of answer set programming. Several results in that theory refer to the concept of the positive dependency graph of a logic program. We describe a modification of that concept and show that the new understanding of positive dependency makes it possible to strengthen some of these results
Treewidth-Aware Complexity in ASP: Not all Positive Cycles are Equally Hard
It is well-know that deciding consistency for normal answer set programs
(ASP) is NP-complete, thus, as hard as the satisfaction problem for classical
propositional logic (SAT). The best algorithms to solve these problems take
exponential time in the worst case. The exponential time hypothesis (ETH)
implies that this result is tight for SAT, that is, SAT cannot be solved in
subexponential time. This immediately establishes that the result is also tight
for the consistency problem for ASP. However, accounting for the treewidth of
the problem, the consistency problem for ASP is slightly harder than SAT: while
SAT can be solved by an algorithm that runs in exponential time in the
treewidth k, it was recently shown that ASP requires exponential time in k
\cdot log(k). This extra cost is due checking that there are no self-supported
true atoms due to positive cycles in the program. In this paper, we refine the
above result and show that the consistency problem for ASP can be solved in
exponential time in k \cdot log({\lambda}) where {\lambda} is the minimum
between the treewidth and the size of the largest strongly-connected component
in the positive dependency graph of the program. We provide a dynamic
programming algorithm that solves the problem and a treewidth-aware reduction
from ASP to SAT that adhere to the above limit
A System for Explainable Answer Set Programming
[Abstract]
We present xclingo, a tool for generating explanations from ASP programs annotated with text and labels. These annotations allow tracing the application of rules or the atoms derived by them. The input of xclingo is a markup language written as ASP comment lines, so the programs annotated in this way can still be accepted by a standard ASP solver. xclingo translates the annotations into additional predicates and rules and uses the ASP solver clingo to obtain the extension of those auxiliary predicates. This information is used afterwards to construct derivation trees containing textual explanations. The language allows selecting which atoms to explain and, in its turn, which atoms or rules to include in those explanations. We illustrate the basic features through a diagnosis problem from the literature.Ministerio de Asuntos Económicos y Transformación Digital; TIN2017-84453-PXunta de Galicia; ED431G 2019/0
Embracing Background Knowledge in the Analysis of Actual Causality: An Answer Set Programming Approach
This paper presents a rich knowledge representation language aimed at
formalizing causal knowledge. This language is used for accurately and directly
formalizing common benchmark examples from the literature of actual causality.
A definition of cause is presented and used to analyze the actual causes of
changes with respect to sequences of actions representing those examples.Comment: Under consideration for publication in Theory and Practice of Logic
Programmin
Abstract Argumentation and Answer Set Programming: Two Faces of Nelson’s Logic
In this work, we show that both logic programming and abstract argumentation frameworks can be interpreted in terms of Nelson’s constructive logic N4. We do so by formalising, in this logic, two principles that we call noncontradictory inference and strengthened closed world assumption: the first states that no belief can be held based on contradictory evidence while the latter forces both unknown and contradictory evidence to be regarded as false. Using these principles, both logic programming and abstract argumentation frameworks are translated into constructive logic in a modular way and using the object language. Logic programming implication and abstract argumentation supports become, in the translation, a new implication connective following the noncontradictory inference principle. Attacks are then represented by combining this new implication with strong negation. Under consideration in Theory and Practice of Logic Programming (TPLP)